home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / programer2 / sdls / DLLLib_h_stdio < prev    next >
Encoding:
Text File  |  1994-03-05  |  34.1 KB  |  696 lines
  1. #pragma force_top_level
  2. #pragma include_only_once
  3.  
  4. /* stdio.h: ANSI 'C' (X3J11 Oct 88) library header, section 4.9 */
  5. /* Copyright (C) Codemist Ltd. */
  6. /* Copyright (C) Acorn Computers Ltd., 1990, 1992 */
  7. /* version 2.00 */
  8.  
  9. /* AM July-88 changes to all prototypes so that                         */
  10. /*      #define mode 3; #include <stdio.h> can work as ANSI require.    */
  11.  
  12. /*
  13.  * stdio.h declares two types, several macros, and many functions for
  14.  * performing input and output. For a discussion on Streams and Files
  15.  * refer to sections 4.9.2 and 4.9.3 in the above ANSI draft, or to a
  16.  * modern textbook on C.
  17.  */
  18.  
  19. #ifndef __stdio_h
  20. #define __stdio_h
  21.  
  22. #define __LIB_VERSION 310       /* 3.10, but int for PP inequality test */
  23.  
  24. #ifndef __size_t
  25. #define __size_t 1
  26. typedef unsigned int size_t;   /* from <stddef.h> */
  27. #endif
  28.  
  29. /* ANSI forbids va_list to be defined here */
  30. typedef char *__va_list[1];       /* keep in step with <stdarg.h> */
  31.  
  32. #ifndef NULL
  33. #  define NULL 0                /* see <stddef.h> */
  34. #endif
  35.  
  36. typedef struct __fpos_t_struct
  37. { unsigned long __lo;             /* add hi one day */
  38. } fpos_t;
  39.    /*
  40.     * fpos_t is an object capable of recording all information needed to
  41.     * specify uniquely every position within a file.
  42.     */
  43.  
  44. typedef struct __FILE_struct
  45. { unsigned char *__ptr;
  46.   int __icnt;      /* two separate _cnt fields so we can police ...        */
  47.   int __ocnt;      /* ... restrictions that read/write are fseek separated */
  48.   int __flag;
  49.   /* AM: the following things do NOT need __ prefixes as they are          */
  50.   /* are invisible in an ANSI-conforming program.                          */
  51.   unsigned char *__base; /* buffer base */
  52.   int __file;            /* RISCOS/Arthur/Brazil file handle */
  53.   long __pos;            /* position in file */
  54.   int __bufsiz;          /* maximum buffer size */
  55.   int __signature;       /* used with temporary files */
  56.   struct __extradata *__extrap; /* pointer to information about stream */
  57. } FILE;
  58.    /*
  59.     * FILE is an object capable of recording all information needed to control
  60.     * a stream, such as its file position indicator, a pointer to its
  61.     * associated buffer, an error indicator that records whether a read/write
  62.     * error has occurred and an end-of-file indicator that records whether the
  63.     * end-of-file has been reached.
  64.     * N.B. the objects contained in the #ifdef __system_io clause are for
  65.     * system use only.
  66.     */
  67.  
  68. # define _IOREAD      0x01 /* system use - open for input */
  69. # define _IOWRITE     0x02 /* system use - open for output */
  70. # define _IOBIN       0x04 /* system use - binary stream */
  71. # define _IOSTRG      0x08 /* system use - string stream */
  72. # define _IOSEEK      0x10 /* system use - physical seek required before IO */
  73. # define _IOLAZY      0x20 /* system use - possible seek pending */
  74. # define _IOSBF      0x800 /* system use - system allocated buffer */
  75. # define _IOAPPEND 0x08000 /* system use - must seek to eof before write */
  76. #define _IOEOF     0x40 /* end-of-file reached */
  77. #define _IOERR     0x80 /* error occurred on stream */
  78. #define _IOFBF    0x100 /* fully buffered IO */
  79. #define _IOLBF    0x200 /* line buffered IO */
  80. #define _IONBF    0x400 /* unbuffered IO */
  81.  
  82. #define BUFSIZ   (4096) /* system buffer size (as used by setbuf) */
  83. #define EOF      (-1)
  84.    /*
  85.     * negative integral constant, indicates end-of-file, that is, no more input
  86.     * from a stream.
  87.     */
  88. /* It is not clear to me what value FOPEN_MAX should have, so I will
  89.    err in the cautious direction - ANSI requires it to be at least 8 */
  90. #define FOPEN_MAX 8           /* check re arthur/unix/mvs */
  91.    /*
  92.     * an integral constant expression that is the minimum number of files that
  93.     * this implementation guarantees can be open simultaneously.
  94.     */
  95. /* _SYS_OPEN defines a limit on the number of open files that is imposed
  96.    by this C library */
  97. #define _SYS_OPEN 16
  98. #define FILENAME_MAX 80
  99.    /*
  100.     * an integral constant expression that is the size of an array of char
  101.     * large enough to hold the longest filename string
  102.     */
  103. #define L_tmpnam FILENAME_MAX
  104.    /*
  105.     * an integral constant expression that is the size of an array of char
  106.     * large enough to hold a temporary file name string generated by the
  107.     * tmpnam function.
  108.     */
  109.  
  110. #ifndef SEEK_SET
  111. #define SEEK_SET 0 /* start of stream (see fseek) */
  112. #define SEEK_CUR 1 /* current position in stream (see fseek) */
  113. #define SEEK_END 2 /* end of stream (see fseek) */
  114. #endif
  115.  
  116. #define TMP_MAX 1000000000
  117.    /*
  118.     * an integral constant expression that is the minimum number of unique
  119.     * file names that shall be generated by the tmpnam function.
  120.     */
  121.  
  122. #ifdef __cplusplus
  123. extern "C" {
  124. #endif
  125.  
  126. #ifdef _DLL
  127.   extern FILE *_dll_iob(void);
  128.   #define __iob (_dll_iob())
  129. #else
  130.   extern FILE __iob[];
  131.      /* an array of file objects for use by the system. */
  132. #endif
  133.  
  134. #ifdef SYSTEM_STATICS
  135.   extern FILE *stdin;
  136.   extern FILE *stdout;
  137.   extern FILE *stderr;
  138. #else
  139.   #define stdin  (&__iob[0])
  140.      /* pointer to a FILE object associated with standard input stream */
  141.   #define stdout (&__iob[1])
  142.      /* pointer to a FILE object associated with standard output stream */
  143.   #define stderr (&__iob[2])
  144.      /* pointer to a FILE object associated with standard error stream */
  145. #endif
  146.  
  147. extern int remove(const char * /*filename*/);
  148.    /*
  149.     * causes the file whose name is the string pointed to by filename to be
  150.     * removed. Subsequent attempts to open the file will fail, unless it is
  151.     * created anew. If the file is open, the behaviour of the remove function
  152.     * is implementation-defined (under RISCOS/Arthur/Brazil the operation
  153.     * fails).
  154.     * Returns: zero if the operation succeeds, nonzero if it fails.
  155.     */
  156. extern int rename(const char * /*old*/, const char * /*new*/);
  157.    /*
  158.     * causes the file whose name is the string pointed to by old to be
  159.     * henceforth known by the name given by the string pointed to by new. The
  160.     * file named old is effectively removed. If a file named by the string
  161.     * pointed to by new exists prior to the call of the rename function, the
  162.     * behaviour is implementation-defined (under RISCOS/Arthur/Brazil, the
  163.     * operation fails).
  164.     * Returns: zero if the operation succeeds, nonzero if it fails, in which
  165.     *          case if the file existed previously it is still known by its
  166.     *          original name.
  167.     */
  168. extern FILE *tmpfile(void);
  169.    /*
  170.     * creates a temporary binary file that will be automatically removed when
  171.     * it is closed or at program termination. The file is opened for update.
  172.     * Returns: a pointer to the stream of the file that it created. If the file
  173.     *          cannot be created, a null pointer is returned.
  174.     */
  175. extern char *tmpnam(char * /*s*/);
  176.    /*
  177.     * generates a string that is not the same as the name of an existing file.
  178.     * The tmpnam function generates a different string each time it is called,
  179.     * up to TMP_MAX times. If it is called more than TMP_MAX times, the
  180.     * behaviour is implementation-defined (under RISCOS/Arthur/Brazil the
  181.     * algorithm for the name generation works just as well after tmpnam has
  182.     * been called more than TMP_MAX times as before; a name clash is impossible
  183.     * in any single half year period).
  184.     * Returns: If the argument is a null pointer, the tmpnam function leaves
  185.     *          its result in an internal static object and returns a pointer to
  186.     *          that object. Subsequent calls to the tmpnam function may modify
  187.     *          the same object. if the argument is not a null pointer, it is
  188.     *          assumed to point to an array of at least L_tmpnam characters;
  189.     *          the tmpnam function writes its result in that array and returns
  190.     *          the argument as its value.
  191.     */
  192.  
  193. extern int fclose(FILE * /*stream*/);
  194.    /*
  195.     * causes the stream pointed to by stream to be flushed and the associated
  196.     * file to be closed. Any unwritten buffered data for the stream are
  197.     * delivered to the host environment to be written to the file; any unread
  198.     * buffered data are discarded. The stream is disassociated from the file.
  199.     * If the associated buffer was automatically allocated, it is deallocated.
  200.     * Returns: zero if the stream was succesfully closed, or nonzero if any
  201.     *          errors were detected or if the stream was already closed.
  202.     */
  203. extern int fflush(FILE * /*stream*/);
  204.    /*
  205.     * If the stream points to an output or update stream in which the most
  206.     * recent operation was output, the fflush function causes any unwritten
  207.     * data for that stream to be delivered to the host environment to be
  208.     * written to the file. If the stream points to an input or update stream,
  209.     * the fflush function undoes the effect of any preceding ungetc operation
  210.     * on the stream.
  211.     * Returns: nonzero if a write error occurs.
  212.     */
  213. extern FILE *fopen(const char * /*filename*/, const char * /*mode*/);
  214.    /*
  215.     * opens the file whose name is the string pointed to by filename, and
  216.     * associates a stream with it.
  217.     * The argument mode points to a string beginning with one of the following
  218.     * sequences:
  219.     * "r"         open text file for reading
  220.     * "w"         create text file for writing, or truncate to zero length
  221.     * "a"         append; open text file or create for writing at eof
  222.     * "rb"        open binary file for reading
  223.     * "wb"        create binary file for writing, or truncate to zero length
  224.     * "ab"        append; open binary file or create for writing at eof
  225.     * "r+"        open text file for update (reading and writing)
  226.     * "w+"        create text file for update, or truncate to zero length
  227.     * "a+"        append; open text file or create for update, writing at eof
  228.     * "r+b"/"rb+" open binary file for update (reading and writing)
  229.     * "w+b"/"wb+" create binary file for update, or truncate to zero length
  230.     * "a+b"/"ab+" append; open binary file or create for update, writing at eof
  231.     *
  232.     * Opening a file with read mode ('r' as the first character in the mode
  233.     * argument) fails if the file does not exist or cannot be read.
  234.     * Opening a file with append mode ('a' as the first character in the mode
  235.     * argument) causes all subsequent writes to be forced to the current end of
  236.     * file, regardless of intervening calls to the fseek function. In some
  237.     * implementations, opening a binary file with append mode ('b' as the
  238.     * second or third character in the mode argument) may initially position
  239.     * the file position indicator beyond the last data written, because of the
  240.     * NUL padding (but not under RISCOS/Arthur/Brazil).
  241.     * When a file is opened with update mode ('+' as the second or third
  242.     * character in the mode argument), both input and output may be performed
  243.     * on the associated stream. However, output may not be directly followed by
  244.     * input without an intervening call to the fflush fuction or to a file
  245.     * positioning function (fseek, fsetpos, or rewind), and input be not be
  246.     * directly followed by output without an intervening call to the fflush
  247.     * fuction or to a file positioning function, unless the input operation
  248.     * encounters end-of-file. Opening a file with update mode may open or
  249.     * create a binary stream in some implementations (but not under RISCOS/
  250.     * Arthur/Brazil). When opened, a stream is fully buffered if and only if
  251.     * it does not refer to an interactive device. The error and end-of-file
  252.     * indicators for the stream are cleared.
  253.     * Returns: a pointer to the object controlling the stream. If the open
  254.     *          operation fails, fopen returns a null pointer.
  255.     */
  256. extern FILE *freopen(const char * /*filename*/, const char * /*mode*/,
  257.                      FILE * /*stream*/);
  258.    /*
  259.     * opens the file whose name is the string pointed to by filename and
  260.     * associates the stream pointed to by stream with it. The mode argument is
  261.     * used just as in the fopen function.
  262.     * The freopen function first attempts to close any file that is associated
  263.     * with the specified stream. Failure to close the file successfully is
  264.     * ignored. The error and end-of-file indicators for the stream are cleared.
  265.     * Returns: a null pointer if the operation fails. Otherwise, freopen
  266.     *          returns the value of the stream.
  267.     */
  268. extern void setbuf(FILE * /*stream*/, char * /*buf*/);
  269.    /*
  270.     * Except that it returns no value, the setbuf function is equivalent to the
  271.     * setvbuf function invoked with the values _IOFBF for mode and BUFSIZ for
  272.     * size, or (if buf is a null pointer), with the value _IONBF for mode.
  273.     * Returns: no value.
  274.     */
  275. extern int setvbuf(FILE * /*stream*/, char * /*buf*/,
  276.                    int /*mode*/, size_t /*size*/);
  277.    /*
  278.     * may be used after the stream pointed to by stream has been associated
  279.     * with an open file but before it is read or written. The argument mode
  280.     * determines how stream will be buffered, as follows: _IOFBF causes
  281.     * input/output to be fully buffered; _IOLBF causes output to be line
  282.     * buffered (the buffer will be flushed when a new-line character is
  283.     * written, when the buffer is full, or when input is requested); _IONBF
  284.     * causes input/output to be completely unbuffered. If buf is not the null
  285.     * pointer, the array it points to may be used instead of an automatically
  286.     * allocated buffer (the buffer must have a lifetime at least as great as
  287.     * the open stream, so the stream should be closed before a buffer that has
  288.     * automatic storage duration is deallocated upon block exit). The argument
  289.     * size specifies the size of the array. The contents of the array at any
  290.     * time are indeterminate.
  291.     * Returns: zero on success, or nonzero if an invalid value is given for
  292.     *          mode or size, or if the request cannot be honoured.
  293.     */
  294.  
  295. #pragma -v1   /* hint to the compiler to check f/s/printf format */
  296. extern int fprintf(FILE * /*stream*/, const char * /*format*/, ...);
  297.    /*
  298.     * writes output to the stream pointed to by stream, under control of the
  299.     * string pointed to by format that specifies how subsequent arguments are
  300.     * converted for output. If there are insufficient arguments for the format,
  301.     * the behaviour is undefined. If the format is exhausted while arguments
  302.     * remain, the excess arguments are evaluated but otherwise ignored. The
  303.     * fprintf function returns when the end of the format string is reached.
  304.     * The format shall be a multibyte character sequence, beginning and ending
  305.     * in its initial shift state. The format is composed of zero or more
  306.     * directives: ordinary multibyte characters (not %), which are copied
  307.     * unchanged to the output stream; and conversion specifiers, each of which
  308.     * results in fetching zero or more subsequent arguments. Each conversion
  309.     * specification is introduced by the character %. For a description of the
  310.     * available conversion specifiers refer to section 4.9.6.1 in the ANSI
  311.     * draft mentioned at the start of this file or to any modern textbook on C.
  312.     * The minimum value for the maximum number of characters producable by any
  313.     * single conversion is at least 509.
  314.     * Returns: the number of characters transmitted, or a negative value if an
  315.     *          output error occurred.
  316.     */
  317. extern int printf(const char * /*format*/, ...);
  318.    /*
  319.     * is equivalent to fprintf with the argument stdout interposed before the
  320.     * arguments to printf.
  321.     * Returns: the number of characters transmitted, or a negative value if an
  322.     *          output error occurred.
  323.     */
  324. extern int sprintf(char * /*s*/, const char * /*format*/, ...);
  325.    /*
  326.     * is equivalent to fprintf, except that the argument s specifies an array
  327.     * into which the generated output is to be written, rather than to a
  328.     * stream. A null character is written at the end of the characters written;
  329.     * it is not counted as part of the returned sum.
  330.     * Returns: the number of characters written to the array, not counting the
  331.     *          terminating null character.
  332.     */
  333. #pragma -v2   /* hint to the compiler to check f/s/scanf format */
  334. extern int fscanf(FILE * /*stream*/, const char * /*format*/, ...);
  335.    /*
  336.     * reads input from the stream pointed to by stream, under control of the
  337.     * string pointed to by format that specifies the admissible input sequences
  338.     * and how thay are to be converted for assignment, using subsequent
  339.     * arguments as pointers to the objects to receive the converted input. If
  340.     * there are insufficient arguments for the format, the behaviour is
  341.     * undefined. If the format is exhausted while arguments remain, the excess
  342.     * arguments are evaluated but otherwise ignored.
  343.     * The format is composed of zero or more directives: one or more
  344.     * white-space characters; an ordinary character (not %); or a conversion
  345.     * specification. Each conversion specification is introduced by the
  346.     * character %. For a description of the available conversion specifiers
  347.     * refer to section 4.9.6.2 in the ANSI draft mentioned at the start of this
  348.     * file, or to any modern textbook on C.
  349.     * If end-of-file is encountered during input, conversion is terminated. If
  350.     * end-of-file occurs before any characters matching the current directive
  351.     * have been read (other than leading white space, where permitted),
  352.     * execution of the current directive terminates with an input failure;
  353.     * otherwise, unless execution of the current directive is terminated with a
  354.     * matching failure, execution of the following directive (if any) is
  355.     * terminated with an input failure.
  356.     * If conversions terminates on a conflicting input character, the offending
  357.     * input character is left unread in the input strem. Trailing white space
  358.     * (including new-line characters) is left unread unless matched by a
  359.     * directive. The success of literal matches and suppressed asignments is
  360.     * not directly determinable other than via the %n directive.
  361.     * Returns: the value of the macro EOF if an input failure occurs before any
  362.     *          conversion. Otherwise, the fscanf function returns the number of
  363.     *          input items assigned, which can be fewer than provided for, or
  364.     *          even zero, in the event of an early conflict between an input
  365.     *          character and the format.
  366.     */
  367. extern int scanf(const char * /*format*/, ...);
  368.    /*
  369.     * is equivalent to fscanf with the argument stdin interposed before the
  370.     * arguments to scanf.
  371.     * Returns: the value of the macro EOF if an input failure occurs before any
  372.     *          conversion. Otherwise, the scanf function returns the number of
  373.     *          input items assigned, which can be fewer than provided for, or
  374.     *          even zero, in the event of an early matching failure.
  375.     */
  376. extern int sscanf(const char * /*s*/, const char * /*format*/, ...);
  377.    /*
  378.     * is equivalent to fscanf except that the argument s specifies a string
  379.     * from which the input is to be obtained, rather than from a stream.
  380.     * Reaching the end of the string is equivalent to encountering end-of-file
  381.     * for the fscanf function.
  382.     * Returns: the value of the macro EOF if an input failure occurs before any
  383.     *          conversion. Otherwise, the scanf function returns the number of
  384.     *          input items assigned, which can be fewer than provided for, or
  385.     *          even zero, in the event of an early matching failure.
  386.     */
  387. #pragma -v0   /* back to default */
  388. extern int vprintf(const char * /*format*/, __va_list /*arg*/);
  389.    /*
  390.     * is equivalent to printf, with the variable argument list replaced by arg,
  391.     * which has been initialised by the va_start macro (and possibly subsequent
  392.     * va_arg calls). The vprintf function does not invoke the va_end function.
  393.     * Returns: the number of characters transmitted, or a negative value if an
  394.     *          output error occurred.
  395.     */
  396. extern int vfprintf(FILE * /*stream*/,
  397.                    const char * /*format*/, __va_list /*arg*/);
  398.    /*
  399.     * is equivalent to fprintf, with the variable argument list replaced by
  400.     * arg, which has been initialised by the va_start macro (and possibly
  401.     * subsequent va_arg calls). The vfprintf function does not invoke the
  402.     * va_end function.
  403.     * Returns: the number of characters transmitted, or a negative value if an
  404.     *          output error occurred.
  405.     */
  406. extern int vsprintf(char * /*s*/, const char * /*format*/, __va_list /*arg*/);
  407.    /*
  408.     * is equivalent to sprintf, with the variable argument list replaced by
  409.     * arg, which has been initialised by the va_start macro (and possibly
  410.     * subsequent va_arg calls). The vsprintf function does not invoke the
  411.     * va_end function.
  412.     * Returns: the number of characters written in the array, not counting the
  413.     *          terminating null character.
  414.     */
  415.  
  416. extern int fgetc(FILE * /*stream*/);
  417.    /*
  418.     * obtains the next character (if present) as an unsigned char converted to
  419.     * an int, from the input stream pointed to by stream, and advances the
  420.     * associated file position indicator (if defined).
  421.     * Returns: the next character from the input stream pointed to by stream.
  422.     *          If the stream is at end-of-file, the end-of-file indicator is
  423.     *          set and fgetc returns EOF. If a read error occurs, the error
  424.     *          indicator is set and fgetc returns EOF.
  425.     */
  426. extern char *fgets(char * /*s*/, int /*n*/, FILE * /*stream*/);
  427.    /*
  428.     * reads at most one less than the number of characters specified by n from
  429.     * the stream pointed to by stream into the array pointed to by s. No
  430.     * additional characters are read after a new-line character (which is
  431.     * retained) or after end-of-file. A null character is written immediately
  432.     * after the last character read into the array.
  433.     * Returns: s if successful. If end-of-file is encountered and no characters
  434.     *          have been read into the array, the contents of the array remain
  435.     *          unchanged and a null pointer is returned. If a read error occurs
  436.     *          during the operation, the array contents are indeterminate and a
  437.     *          null pointer is returned.
  438.     */
  439. extern int fputc(int /*c*/, FILE * /*stream*/);
  440.    /*
  441.     * writes the character specified by c (converted to an unsigned char) to
  442.     * the output stream pointed to by stream, at the position indicated by the
  443.     * asociated file position indicator (if defined), and advances the
  444.     * indicator appropriately. If the file position indicator is not defined,
  445.     * the character is appended to the output stream.
  446.     * Returns: the character written. If a write error occurs, the error
  447.     *          indicator is set and fputc returns EOF.
  448.     */
  449. extern int fputs(const char * /*s*/, FILE * /*stream*/);
  450.    /*
  451.     * writes the string pointed to by s to the stream pointed to by stream.
  452.     * The terminating null character is not written.
  453.     * Returns: EOF if a write error occurs; otherwise it returns a nonnegative
  454.     *          value.
  455.     */
  456. extern int __filbuf(FILE * /*stream*/);
  457.    /*
  458.     * SYSTEM USE ONLY, called by getc to refill buffer and or sort out flags.
  459.     * Returns: first character put into buffer or EOF on error.
  460.     */
  461. #define getc(p) \
  462.     (--((p)->__icnt) >= 0 ? *((p)->__ptr)++ : __filbuf(p))
  463. #ifndef __cplusplus
  464. extern int (getc)(FILE * /*stream*/);
  465. #endif
  466.    /*
  467.     * is equivalent to fgetc except that it may be (and is under
  468.     * RISCOS/Arthur/Brazil) implemented as a macro. stream may be evaluated
  469.     * more than once, so the argument should never be an expression with side
  470.     * effects.
  471.     * Returns: the next character from the input stream pointed to by stream.
  472.     *          If the stream is at end-of-file, the end-of-file indicator is
  473.     *          set and getc returns EOF. If a read error occurs, the error
  474.     *          indicator is set and getc returns EOF.
  475.     */
  476. #define getchar() getc(stdin)
  477. #ifndef __cplusplus
  478. extern int (getchar)(void);
  479. #endif
  480.    /*
  481.     * is equivalent to getc with the argument stdin.
  482.     * Returns: the next character from the input stream pointed to by stdin.
  483.     *          If the stream is at end-of-file, the end-of-file indicator is
  484.     *          set and getchar returns EOF. If a read error occurs, the error
  485.     *          indicator is set and getchar returns EOF.
  486.     */
  487. extern char *gets(char * /*s*/);
  488.    /*
  489.     * reads characters from the input stream pointed to by stdin into the array
  490.     * pointed to by s, until end-of-file is encountered or a new-line character
  491.     * is read. Any new-line character is discarded, and a null character is
  492.     * written immediately after the last character read into the array.
  493.     * Returns: s if successful. If end-of-file is encountered and no characters
  494.     *          have been read into the array, the contents of the array remain
  495.     *          unchanged and a null pointer is returned. If a read error occurs
  496.     *          during the operation, the array contents are indeterminate and a
  497.     *          null pointer is returned.
  498.     */
  499. extern int __flsbuf(int /*c*/, FILE * /*stream*/);
  500.    /*
  501.     * SYSTEM USE ONLY, called by putc to flush buffer and or sort out flags.
  502.     * Returns: character put into buffer or EOF on error.
  503.     */
  504. #define putc(ch, p) \
  505.     (--((p)->__ocnt) >= 0 ? (*((p)->__ptr)++ = (ch)) : __flsbuf(ch,p))
  506. #ifndef __cplusplus
  507. extern int (putc)(int /*c*/, FILE * /*stream*/);
  508. #endif
  509.    /*
  510.     * is equivalent to fputc except that it may be (and is under
  511.     * RISCOS/Arthur/Brazil) implemented as a macro. stream may be evaluated
  512.     * more than once, so the argument should never be an expression with side
  513.     * effects.
  514.     * Returns: the character written. If a write error occurs, the error
  515.     *          indicator is set and putc returns EOF.
  516.     */
  517. #define putchar(ch) putc(ch, stdout)
  518. #ifndef __cplusplus
  519. extern int (putchar)(int /*c*/);
  520. #endif
  521.    /*
  522.     * is equivalent to putc with the second argument stdout.
  523.     * Returns: the character written. If a write error occurs, the error
  524.     *          indicator is set and putc returns EOF.
  525.     */
  526. extern int puts(const char * /*s*/);
  527.    /*
  528.     * writes the string pointed to by s to the stream pointed to by stdout, and
  529.     * appends a new-line character to the output. The terminating null
  530.     * character is not written.
  531.     * Returns: EOF if a write error occurs; otherwise it returns a nonnegative
  532.     *          value.
  533.     */
  534. extern int ungetc(int /*c*/, FILE * /*stream*/);
  535.    /*
  536.     * pushes the character specified by c (converted to an unsigned char) back
  537.     * onto the input stream pointed to by stream. The character will be
  538.     * returned by the next read on that stream. An intervening call to the
  539.     * fflush function or to a file positioning function (fseek, fsetpos,
  540.     * rewind) discards any pushed-back characters. The external storage
  541.     * corresponding to the stream is unchanged.
  542.     * One character pushback is guaranteed. If the unget function is called too
  543.     * many times on the same stream without an intervening read or file
  544.     * positioning operation on that stream, the operation may fail.
  545.     * If the value of c equals that of the macro EOF, the operation fails and
  546.     * the input stream is unchanged.
  547.     * A successful call to the ungetc function clears the end-of-file
  548.     * indicator. The value of the file position indicator after reading or
  549.     * discarding all pushed-back characters shall be the same as it was before
  550.     * the characters were pushed back. For a text stream, the value of the file
  551.     * position indicator after a successful call to the ungetc function is
  552.     * unspecified until all pushed-back characters are read or discarded. For a
  553.     * binary stream, the file position indicator is decremented by each
  554.     * successful call to the ungetc function; if its value was zero before a
  555.     * call, it is indeterminate after the call.
  556.     * Returns: the character pushed back after conversion, or EOF if the
  557.     *          operation fails.
  558.     */
  559.  
  560. extern size_t fread(void * /*ptr*/,
  561.                     size_t /*size*/, size_t /*nmemb*/, FILE * /*stream*/);
  562.    /*
  563.     * reads into the array pointed to by ptr, up to nmemb members whose size is
  564.     * specified by size, from the stream pointed to by stream. The file
  565.     * position indicator (if defined) is advanced by the number of characters
  566.     * successfully read. If an error occurs, the resulting value of the file
  567.     * position indicator is indeterminate. If a partial member is read, its
  568.     * value is indeterminate. The ferror or feof function shall be used to
  569.     * distinguish between a read error and end-of-file.
  570.     * Returns: the number of members successfully read, which may be less than
  571.     *          nmemb if a read error or end-of-file is encountered. If size or
  572.     *          nmemb is zero, fread returns zero and the contents of the array
  573.     *          and the state of the stream remain unchanged.
  574.     */
  575. extern size_t fwrite(const void * /*ptr*/,
  576.                     size_t /*size*/, size_t /*nmemb*/, FILE * /*stream*/);
  577.    /*
  578.     * writes, from the array pointed to by ptr up to nmemb members whose size
  579.     * is specified by size, to the stream pointed to by stream. The file
  580.     * position indicator (if defined) is advanced by the number of characters
  581.     * successfully written. If an error occurs, the resulting value of the file
  582.     * position indicator is indeterminate.
  583.     * Returns: the number of members successfully written, which will be less
  584.     *          than nmemb only if a write error is encountered.
  585.     */
  586.  
  587. extern int fgetpos(FILE * /*stream*/, fpos_t * /*pos*/);
  588.    /*
  589.     * stores the current value of the file position indicator for the stream
  590.     * pointed to by stream in the object pointed to by pos. The value stored
  591.     * contains unspecified information usable by the fsetpos function for
  592.     * repositioning the stream to its position at the time  of the call to the
  593.     * fgetpos function.
  594.     * Returns: zero, if successful. Otherwise nonzero is returned and the
  595.     *          integer expression errno is set to an implementation-defined
  596.     *          nonzero value (under RISCOS/Arthur/Brazil fgetpos cannot fail).
  597.     */
  598. extern int fseek(FILE * /*stream*/, long int /*offset*/, int /*whence*/);
  599.    /*
  600.     * sets the file position indicator for the stream pointed to by stream.
  601.     * For a binary stream, the new position is at the signed number of
  602.     * characters specified by offset away from the point specified by whence.
  603.     * The specified point is the beginning of the file for SEEK_SET, the
  604.     * current position in the file for SEEK_CUR, or end-of-file for SEEK_END.
  605.     * A binary stream need not meaningfully support fseek calls with a whence
  606.     * value of SEEK_END.
  607.     * For a text stream, either offset shall be zero, or offset shall be a
  608.     * value returned by an earlier call to the ftell function on the same
  609.     * stream and whence shall be SEEK_SET.
  610.     * The fseek function clears the end-of-file indicator and undoes any
  611.     * effects of the ungetc function on the same stream. After an fseek call,
  612.     * the next operation on an update stream may be either input or output.
  613.     * Returns: nonzero only for a request that cannot be satisfied.
  614.     */
  615. extern int fsetpos(FILE * /*stream*/, const fpos_t * /*pos*/);
  616.    /*
  617.     * sets  the file position indicator for the stream pointed to by stream
  618.     * according to the value of the object pointed to by pos, which shall be a
  619.     * value returned by an earlier call to the fgetpos function on the same
  620.     * stream.
  621.     * The fsetpos function clears the end-of-file indicator and undoes any
  622.     * effects of the ungetc function on the same stream. After an fsetpos call,
  623.     * the next operation on an update stream may be either input or output.
  624.     * Returns: zero, if successful. Otherwise nonzero is returned and the
  625.     *          integer expression errno is set to an implementation-defined
  626.     *          nonzero value (under RISCOS/Arthur/Brazil the value that of EDOM
  627.     *          in math.h).
  628.     */
  629. extern long int ftell(FILE * /*stream*/);
  630.    /*
  631.     * obtains the current value of the file position indicator for the stream
  632.     * pointed to by stream. For a binary stream, the value is the number of
  633.     * characters from the beginning of the file. For a text stream, the file
  634.     * position indicator contains unspecified information, usable by the fseek
  635.     * function for returning the file position indicator to its position at the
  636.     * time of the ftell call; the difference between two such return values is
  637.     * not necessarily a meaningful measure of the number of characters written
  638.     * or read.
  639.     * Returns: if successful, the current value of the file position indicator.
  640.     *          On failure, the ftell function returns -1L and sets the integer
  641.     *          expression errno to an implementation-defined nonzero value
  642.     *          (under RISCOS/Arthur/Brazil ftell cannot fail).
  643.     */
  644. extern void rewind(FILE * /*stream*/);
  645.    /*
  646.     * sets the file position indicator for the stream pointed to by stream to
  647.     * the beginning of the file. It is equivalent to
  648.     *          (void)fseek(stream, 0L, SEEK_SET)
  649.     * except that the error indicator for the stream is also cleared.
  650.     * Returns: no value.
  651.     */
  652.  
  653. extern void clearerr(FILE * /*stream*/);
  654.    /*
  655.     * clears the end-of-file and error indicators for the stream pointed to by
  656.     * stream. These indicators are cleared only when the file is opened or by
  657.     * an explicit call to the clearerr function or to the rewind function.
  658.     * Returns: no value.
  659.     */
  660.  
  661. #define feof(stream) ((stream)->__flag & _IOEOF)
  662. #ifndef __cplusplus
  663. extern int (feof)(FILE * /*stream*/);
  664. #endif
  665.    /*
  666.     * tests the end-of-file indicator for the stream pointed to by stream.
  667.     * Returns: nonzero iff the end-of-file indicator is set for stream.
  668.     */
  669. #define ferror(stream) ((stream)->__flag & _IOERR)
  670. #ifndef __cplusplus
  671. extern int (ferror)(FILE * /*stream*/);
  672. #endif
  673.    /*
  674.     * tests the error indicator for the stream pointed to by stream.
  675.     * Returns: nonzero iff the error indicator is set for stream.
  676.     */
  677. extern void perror(const char * /*s*/);
  678.    /*
  679.     * maps the error number  in the integer expression errno to an error
  680.     * message. It writes a sequence of characters to the standard error stream
  681.     * thus: first (if s is not a null pointer and the character pointed to by
  682.     * s is not the null character), the string pointed to by s followed by a
  683.     * colon and a space; then an appropriate error message string followed by
  684.     * a new-line character. The contents of the error message strings are the
  685.     * same as those returned by the strerror function with argument errno,
  686.     * which are implementation-defined.
  687.     * Returns: no value.
  688.     */
  689. #ifdef __cplusplus
  690. }
  691. #endif
  692.  
  693. #endif
  694.  
  695. /* end of stdio.h */
  696.